167 research outputs found
Symbolic Implementation of Connectors in BIP
BIP is a component framework for constructing systems by superposing three
layers of modeling: Behavior, Interaction, and Priority. Behavior is
represented by labeled transition systems communicating through ports.
Interactions are sets of ports. A synchronization between components is
possible through the interactions specified by a set of connectors. When
several interactions are possible, priorities allow to restrict the
non-determinism by choosing an interaction, which is maximal according to some
given strict partial order.
The BIP component framework has been implemented in a language and a
tool-set. The execution of a BIP program is driven by a dedicated engine, which
has access to the set of connectors and priority model of the program. A key
performance issue is the computation of the set of possible interactions of the
BIP program from a given state.
Currently, the choice of the interaction to be executed involves a costly
exploration of enumerative representations for connectors. This leads to a
considerable overhead in execution times. In this paper, we propose a symbolic
implementation of the execution model of BIP, which drastically reduces this
overhead. The symbolic implementation is based on computing boolean
representation for components, connectors, and priorities with an existing BDD
package
Interstitial fluid glucose is not just a shifted-in-time but a distorted mirror of blood glucose: Insight from an in Silico study
Glucose sensors measure glucose concentration in the interstitial fluid (ISF), remote from blood. ISF glucose is well known to be "delayed" with respect to blood glucose (BG). However, ISF glucose is not simply a shifted-in-time version of BG but exhibits a more complex pattern.
METHODS:
To gain insight into this problem, one can use linear systems theory. However, this may lose a more clinical readership, thus we use simulation and two case studies to convey our thinking in an easier way. In particular, we consider BG concentration measured after meal and exercise in 12 healthy volunteers, whereas ISF glucose is simulated using a well-accepted model of blood-ISF glucose kinetics, which permits calculation of the equilibration time, a parameter characterizing the system. Two metrics are defined: blood and ISF glucose difference at each time point and time to reach the same glucose value in blood and ISF.
RESULTS:
The simulation performed and the two metrics show that the relationship between blood-ISF glucose profiles is more complex than a pure shift in time and that the pattern depends on both equilibration time and BG.
CONCLUSIONS:
In this in silico study, we have illustrated, with simple case studies, the meaning of the of ISF glucose with respect to BG. Understanding that ISF glucose is not just a shifted-in-time version but a distorted mirror of BG is important for a correct use of continuous glucose monitoring for diabetes management
Implementing Distributed Controllers for Systems with Priorities
Implementing a component-based system in a distributed way so that it ensures
some global constraints is a challenging problem. We consider here abstract
specifications consisting of a composition of components and a controller given
in the form of a set of interactions and a priority order amongst them. In the
context of distributed systems, such a controller must be executed in a
distributed fashion while still respecting the global constraints imposed by
interactions and priorities.
We present in this paper an implementation of an algorithm that allows a
distributed execution of systems with (binary) interactions and priorities. We
also present a comprehensive simulation analysis that shows how sensitive to
changes our algorithm is, in particular changes related to the degree of
conflict in the system.Comment: In Proceedings FOCLASA 2010, arXiv:1007.499
Component Assemblies in the Context of Manycore
International audienceWe present a component-based software design flow for building parallel applications running on top of manycore platforms. The flow is based on the BIP - Behaviour, Interaction, Priority - component frameworkand its associated toolbox. It provides full support for modeling of application software, validation of its functional correctness, modeling and performance analysis on system-level models, code generation and deployment on target manycore platforms. The paper details some of the steps of the design flow. The design flow is illustrated through the modeling and deployment of two applications, the Cholesky factorization and the MJPEG decoding on MPARM, an ARM-based manycore platform. We emphasize the merits of the design flow, notably fast performance analysis as well as code generation and effi cient deployment on manycore platforms
System-Level Modeling, Analysis and Code Generation: Object Recognition Case Study
International audienceOne of the most important challenges in complex embedded systems design is developing methods and tools for modeling and analyzing the behavior of application software running on multi-processor platforms. We propose a tool-supported flow for systematic and compositional construction of mixed software/hardware system models. These models are intended to represent, in an operational way, the set of timed executions of parallel application software statically mapped on a multi-processor platform. As such, system models will be used for performance analysis using simulation-based techniques as well as for code generation on specific platforms. The construction of the system model proceeds in two steps. In the first step, an abstract system model is obtained by composition and specific transformations of (1) the (untimed) model of the application software, (2) the model of the platform and (3) the mapping between them. In the second step, the abstract system model is refined into concrete system model, by including specific timing constraints for execution of the application software, according to chosen mapping on the platform. We illustrate the system model construction method and its use for performance analysis and code generation on an object recognition application provided by Hellenic Airspace Industry. This case study is build upon the HMAX models algorithm [RP99] and is looking at significant speedup factors. This paper reports results obtained on different system model configurations and used to determine the optimal implementation strategy in accordance to hardware resources
Priority scheduling of distributed systems based on model checking
Priorities are used to control the execution of systems to meet given requirements for optimal use of resources, e.g., by using scheduling policies. For distributed systems, it is hard to find efficient implementations for priorities; because they express constraints on global states, their implementation may incur considerable overhead. Our method is based on performing model checking for knowledge properties. It allows identifying where the local information of a process is sufficient to schedule the execution of a high priority transition. As a result of the model checking, the program is transformed to react upon the knowledge it has at each point. The transformed version has no priorities, and uses the gathered information and its knowledge to limit the enabledness of transitions so that it matches or approximates the original specification of priorities. © 2009 Springer Berlin Heidelberg
Statistical Model Checking for Stochastic Hybrid Systems
This paper presents novel extensions and applications of the UPPAAL-SMC model
checker. The extensions allow for statistical model checking of stochastic
hybrid systems. We show how our race-based stochastic semantics extends to
networks of hybrid systems, and indicate the integration technique applied for
implementing this semantics in the UPPAAL-SMC simulation engine. We report on
two applications of the resulting tool-set coming from systems biology and
energy aware buildings.Comment: In Proceedings HSB 2012, arXiv:1208.315
Distributed semantics and implementation for systems with interaction and priority
The paper studies a distributed implementation method for the BIP (Behavior, Interaction, Priority) component framework for modeling heterogeneous systems. BIP offers two powerful mechanisms for describing composition of components by combining interactions and priorities. A system model is layered. The lowest layer contains atomic components; the second layer, describes possible interactions between atomic components; the third layer includes priorities between the interactions. The current implementation of BIP is based on global state operational semantics. An Engine directly interprets the operational semantics rules and computes the possible interactions between atomic components from global states. The implementation method is a translation from BIP models into distributed models involving two steps. The first translates BIP models into partial state models where are known only the states of the components which are ready to communicate. The second implements interactions in the partial state model by using message passing primitives. The main results of the paper are conditions for which the three models are observationally equivalent. We show that in general, the translation from global state to partial state models does not preserve observational equivalence. Preservation can be achieved by strengthening the premises of the operational semantics rules by an oracle. This is a predicate depending on the priorities of the BIP model. We show that there are many possible choices for oracles. Maximal parallelism is achieved for dynamic oracles allowing interaction as soon as possible. Nonetheless, these oracles may entail considerable computational overhead. We study performance trade-offs for different types of oracles. Finally, we provide experimental results illustrating the application of the theory on a prototype implementation. © 2008 Springer-Verlag Berlin Heidelberg
- …